module klang.ir.打印输出.IR打印输出_;
import 全局;
import std.conv: ·to = to;
import std.functional: ·fd = toDelegate;
import klang.编译.输出工具.输出工具_: 打印机基础环境_, 设置打印选项, 设置基础环境, 输出源文件, writeTokenNode, writePunctuation, writeKeyword, _printNode = printNode, _printList = printList, _printFile = printFile, _writeNode = writeNode, _writeList = writeList, _writeFile = writeFile, writeSpace, writeLine, emit, emitList, emitNodeList, emitShebangIfNeeded, emitTokenWithComment;
import 编译数字 = 编译数字.编译;
import klang.编译.类型.枚举值.枚举值_: TK, SK;
import klang.编译.核心.核心_: 整数_, 词典_, 返回零值, 循环每个, 查找数组索引, 创建数组;
import klang.编译.系统.系统_: sys;
import klang.编译.类型.类型_: 文本范围_, 源映射范围_, 编译选项基类_, 基础符号_ = 符号_, TransformationResult, 打印机_, 打印选项_, 打印助手_, SourceMapGenerator, EmitHint, IEmitTextWriter, ListFormat, 新行种类_;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 基础源文件_ = 源文件_, 节点数组_, 分离注释信息_, nodeIsSynthesized, positionIsSynthesized;
import klang.编译.输出节点.输出节点_: 合成注释_, 输出节点_, EmitFlags, getEmitFlags;
import klang.编译.转换.转换_: noEmitSubstitution, noEmitNotification;
import klang.ir.常量值.IR常量值_: 获取ISK关键字文本;
import klang.ir.类型.IR类型_: ISK, 标识符分类_, 节点标志_;
import klang.ir.语法节点.IR节点_: 节点_ = IR节点_, 源文件_ = IR源文件_, 目标语句_, 源码文件名语句_, 函数声明_, 函数定义_, 函数体_, 别名声明_, 块声明_, 模块级汇编_, 全局变量声明_, 封装声明_, 类型声明_, 独立元数据_, 元数据声明_, 特性声明_, 用户历史数据_, 用户历史数据_基本块_, 全局摘要声明_, 整数类型_, 指针类型_, 函数类型_, 不透明指针类型_, 结构类型_, 数组类型_, 向量类型_, 形参声明_, 局部变量声明_, 不及指令_, 返回指令_, 跳转指令_, 假如指令_, 直接跳转指令_, 唤出指令_, 重启指令_, 清理返回指令_, 捕获返回指令_, 捕获分支指令_, 捕获场指令_, 清理场指令_, 调用跳转指令_, 取反指令_, 整数和差积及左移指令_, 小数和差积及左移指令_, 有无符号求商及右移指令_, 有无符号求余数运算指令_, 位运算指令_, 比较运算指令_, 选择指令_, 转换类指令_, 可变参数指令_, 提取元素指令_, 插入元素指令_, 洗牌向量指令_, PHI节点指令_, 着陆场指令_, 调用指令_, 分配指令_, 加载指令_, 储存指令_, 原子修改内存按条件指令_, 原子修改内存指令_, 栅格指令_, 获取元素指针指令_, 提取值指令_, 插入值指令_, 结构常量表达式_, 向量常量表达式_, 数组常量表达式_, c文本常量_, 内联汇编常量表达式_, 块地址表常量表达式_, DSO局部等效常量表达式_, 常量转换类节点_, 提取值常量表达式_, 插入值常量表达式_, 比较类常量表达式_, 取反常量表达式_, 二元常量表达式_, 逻辑类常量表达式_, 获取元素指针常量表达式_, 向量洗牌常量表达式_, 插入元素常量表达式_, 提取元素常量表达式_, 选择常量表达式_, 操作数标签组_, 操作数标签_, PHI节点元素_, 捕获或过滤器_, 同步范围设置_, IR文本字面量_, IR数字字面量_, IRc文本字面量_, IR标识符_, 全局表达式_, 自定义特性设置_, 对齐设置_, 不可引用的设置_, 不可引用的或空设置_, 对齐堆栈设置_, 分配大小设置_, 分配大小设置内容_, 倍数范围设置_, 倍数范围设置内容_, 地址空间设置_, 按引用设置_, 结构引用设置_, 预分配设置_, 在内部分配设置_, 按值设置_, 平台设置_, 数据布局设置_, 封装设置_, CC调用约定设置_, 类型引用_, 值表达式_, 跳转表元素_, 实参表达式_, 冻结指令_, 本地线程设置_, MDNodeVector_, DIExpression_, DIArgList_, 专用元数据字段_, 元数据字段_, 数据计算字段_, 全局值摘要_, 摘要多值设置_, 函数摘要_, 摘要值设置_, 全局值引用摘要_, 被调用者摘要_, 虚函数id摘要_, 常量虚调用摘要_, 虚函数摘要_, 别名摘要_, 形参偏移摘要_, 形参访问调用摘要_, 形参访问摘要_, 变量摘要_, 模块摘要_, 偏移及引用_, 类型id内容摘要_, 类型id兼容表摘要_, 空语句_;
class IR打印_ : 打印机_ {
    this() { }
    override dstring printNode(EmitHint hint, 基础节点_ node, 基础源文件_ sourceFile) {
        return _printNode(hint, node, sourceFile);
    }
    override dstring printList(ListFormat format, 节点数组_!(基础节点_) list, 基础源文件_ sourceFile) {
        return _printList(format, list, sourceFile);
    }
    override dstring printFile(基础源文件_ sourceFile) {
        return _printFile(sourceFile);
    }
    override void writeNode(EmitHint hint, 基础节点_ node, 基础源文件_ sourceFile = ··null!(基础源文件_), IEmitTextWriter writer = ··null!(IEmitTextWriter)) {
        _writeNode(hint, node, sourceFile, writer);
    }
    override void writeList(ListFormat format, 节点数组_!(基础节点_) list = ··null!(节点数组_!(基础节点_)), 基础源文件_ sourceFile = ··null!(基础源文件_), IEmitTextWriter writer = ··null!(IEmitTextWriter)) {
        if ((list is null) || (list.原型 is ··null!(基础节点_[]))) {
            return;
        }
        _writeList(format, list, sourceFile, writer);
    }
    override void writeFile(基础源文件_ sourceFile, IEmitTextWriter writer, SourceMapGenerator sourceMapGenerator = ··null!(SourceMapGenerator)) {
        _writeFile(sourceFile, writer, sourceMapGenerator);
    }
}
打印机_ IR创建输出打印机(TransformationResult r) {
    打印选项_ 打印选项 = new 打印选项_("IR打印选项"d);
    打印选项.removeComments = false;
    打印选项.newLine = 新行种类_.CarriageReturnLineFeed;
    打印选项.noEmitHelpers = true;
    打印选项.sourceMap = false;
    打印选项.inlineSourceMap = false;
    打印选项.inlineSources = false;
    打印选项.extendedDiagnostics = true;
    打印选项.writeBundleFileInfo = false;
    打印助手_ 打印助手 = 打印助手_();
    打印助手.onEmitNode = r.emitNodeWithNotification;
    打印助手.isEmitNotificationEnabled = r.isEmitNotificationEnabled;
    打印助手.substituteNode = r.substituteNode;
    return .IR创建打印机(打印选项, 打印助手);
}
打印机_ IR创建打印机(打印选项_ _打印选项, 打印助手_ _打印助手) {
    设置打印选项(_打印选项);
    打印机基础环境_ _基础环境 = new 打印机基础环境_(/* 目标 */ TK.Ir, /* 单行注释头 */ ";"d, /* 多行注释头 */ ""d, /*_多行注释尾 */ ""d);
    设置基础环境(_打印助手, _基础环境, cast(void delegate(EmitHint, 基础节点_, void delegate(EmitHint, 基础节点_)))(·fd(&noEmitNotification)), cast(基础节点_ delegate(EmitHint, 基础节点_))(·fd(&noEmitSubstitution)), cast(dstring delegate(long))(·fd(&.获取关键字)), cast(bool delegate(基础节点_))(·fd(&.节点是否输出注释)), cast(bool delegate(基础节点_))(·fd(&.应停止注释输出)), cast(void delegate(EmitHint, 基础节点_))(·fd(&.pipelineEmitWithHintWorker)), cast(节点数组_!(基础节点_) delegate(基础节点_))(·fd(&.getContainingNodeArray)));
    return new IR打印_();
}
节点数组_!(基础节点_) getContainingNodeArray(基础节点_ n) {
    return 返回零值!(节点数组_!(基础节点_))();
}
dstring 获取关键字(long token) {
    return 获取ISK关键字文本(token);
}
bool 节点是否输出注释(基础节点_ node) {
    return node.种类 != SK.源文件;
}
bool 应停止注释输出(基础节点_ node) {
    return node.目标种类 != ISK.局部变量声明;
}
// 私有函数
void pipelineEmitWithHintWorker(EmitHint hint, 基础节点_ node) {
    if (node.种类 == SK.源文件) {
        return 输出源文件((cast(源文件_)((cast(基础源文件_)(node)))));
    }
    节点_ n = (cast(节点_)(node));
    switch (n.目标种类) {
        case ISK.空语句: {
            return .输出空语句((cast(空语句_)(n)));
        }
        case ISK.平台设置: {
            return .输出平台设置((cast(平台设置_)(n)));
        }
        case ISK.数据布局设置: {
            return .输出数据布局设置((cast(数据布局设置_)(n)));
        }
        case ISK.目标语句: {
            return .输出目标语句((cast(目标语句_)(n)));
        }
        case ISK.源码文件名语句: {
            return .输出源码文件名语句((cast(源码文件名语句_)(n)));
        }
        case ISK.函数定义: {
            return .输出函数定义((cast(函数定义_)(n)));
        }
        case ISK.函数体: {
            return .输出函数体((cast(函数体_)(n)));
        }
        case ISK.函数声明: {
            return .输出函数声明((cast(函数声明_)(n)));
        }
        case ISK.封装设置: {
            return .输出封装设置((cast(封装设置_)(n)));
        }
        case ISK.块声明: {
            return .输出块声明((cast(块声明_)(n)));
        }
        case ISK.模块级汇编: {
            return .输出模块级汇编((cast(模块级汇编_)(n)));
        }
        case ISK.别名声明: {
            return .输出别名声明((cast(别名声明_)(n)));
        }
        case ISK.全局变量声明: {
            return .输出全局变量声明((cast(全局变量声明_)(n)));
        }
        case ISK.封装声明: {
            return .输出封装声明((cast(封装声明_)(n)));
        }
        case ISK.类型声明: {
            return .输出类型声明((cast(类型声明_)(n)));
        }
        case ISK.独立元数据: {
            return .输出独立元数据((cast(独立元数据_)(n)));
        }
        case ISK.元数据声明: {
            return .输出元数据声明((cast(元数据声明_)(n)));
        }
        case ISK.特性声明: {
            return .输出特性声明((cast(特性声明_)(n)));
        }
        case ISK.用户历史数据: {
            return .输出用户历史数据((cast(用户历史数据_)(n)));
        }
        case ISK.用户历史数据_基本块: {
            return .输出用户历史数据_基本块((cast(用户历史数据_基本块_)(n)));
        }
        case ISK.全局摘要声明: {
            return .输出全局摘要声明((cast(全局摘要声明_)(n)));
        }
        // 类型
        case ISK.整数类型: {
            return .输出整数类型((cast(整数类型_)(n)));
        }
        case ISK.指针类型: {
            return .输出指针类型((cast(指针类型_)(n)));
        }
        case ISK.函数类型: {
            return .输出函数类型((cast(函数类型_)(n)));
        }
        case ISK.ptr: {
            return .输出不透明指针类型((cast(不透明指针类型_)(n)));
        }
        case ISK.结构类型: {
            return .输出结构类型((cast(结构类型_)(n)));
        }
        case ISK.数组类型: {
            return .输出数组类型((cast(数组类型_)(n)));
        }
        case ISK.向量类型: {
            return .输出向量类型((cast(向量类型_)(n)));
        }
        case ISK.类型引用: {
            return .输出类型引用((cast(类型引用_)(n)));
        }
        case ISK.void_:
        case ISK.half:
        case ISK.bfloat:
        case ISK.float_:
        case ISK.double_:
        case ISK.x86_fp80:
        case ISK.fp128:
        case ISK.ppc_fp128:
        case ISK.label:
        case ISK.metadata:
        case ISK.x86_mmx:
        case ISK.x86_amx:
        case ISK.token:
        case ISK.三点号: {
            return writeTokenNode(n, cast(void delegate(dstring))(·fd(&writeKeyword)));
        }
        // 声明;
        case ISK.形参声明: {
            return .输出形参声明((cast(形参声明_)(n)));
        }
        case ISK.局部变量声明: {
            return .输出局部变量声明((cast(局部变量声明_)(n)));
        }
        case ISK.不及指令: {
            return .输出不及指令((cast(不及指令_)(n)));
        }
        case ISK.返回指令: {
            return .输出返回指令((cast(返回指令_)(n)));
        }
        case ISK.跳转指令: {
            return .输出跳转指令((cast(跳转指令_)(n)));
        }
        case ISK.假如指令: {
            return .输出假如指令((cast(假如指令_)(n)));
        }
        case ISK.跳转表元素: {
            return .输出跳转表元素((cast(跳转表元素_)(n)));
        }
        case ISK.直接跳转指令: {
            return .输出直接跳转指令((cast(直接跳转指令_)(n)));
        }
        case ISK.唤出指令: {
            return .输出唤出指令((cast(唤出指令_)(n)));
        }
        case ISK.重启指令: {
            return .输出重启指令((cast(重启指令_)(n)));
        }
        case ISK.清理返回指令: {
            return .输出清理返回指令((cast(清理返回指令_)(n)));
        }
        case ISK.捕获返回指令: {
            return .输出捕获返回指令((cast(捕获返回指令_)(n)));
        }
        case ISK.捕获分支指令: {
            return .输出捕获分支指令((cast(捕获分支指令_)(n)));
        }
        case ISK.捕获场指令: {
            return .输出捕获场指令((cast(捕获场指令_)(n)));
        }
        case ISK.清理场指令: {
            return .输出清理场指令((cast(清理场指令_)(n)));
        }
        case ISK.调用跳转指令: {
            return .输出调用跳转指令((cast(调用跳转指令_)(n)));
        }
        // 一元表达式
        case ISK.取反指令: {
            return .输出取反指令((cast(取反指令_)(n)));
        }
        // 二元表达式;
        case ISK.整数和差积及左移指令: {
            return .输出整数和差积及左移指令((cast(整数和差积及左移指令_)(n)));
        }
        case ISK.小数和差积及左移指令: {
            return .输出小数和差积及左移指令((cast(小数和差积及左移指令_)(n)));
        }
        case ISK.有无符号求商及右移指令: {
            return .输出有无符号求商及右移指令((cast(有无符号求商及右移指令_)(n)));
        }
        case ISK.有无符号求余数运算指令: {
            return .输出有无符号求余数运算指令((cast(有无符号求余数运算指令_)(n)));
        }
        case ISK.位运算指令: {
            return .输出位运算指令((cast(位运算指令_)(n)));
        }
        case ISK.比较运算指令: {
            return .输出比较运算指令((cast(比较运算指令_)(n)));
        }
        case ISK.选择指令: {
            return .输出选择指令((cast(选择指令_)(n)));
        }
        case ISK.转换类指令: {
            return .输出转换类指令((cast(转换类指令_)(n)));
        }
        case ISK.可变参数指令: {
            return .输出可变参数指令((cast(可变参数指令_)(n)));
        }
        case ISK.提取元素指令: {
            return .输出提取元素指令((cast(提取元素指令_)(n)));
        }
        case ISK.插入元素指令: {
            return .输出插入元素指令((cast(插入元素指令_)(n)));
        }
        case ISK.洗牌向量指令: {
            return .输出洗牌向量指令((cast(洗牌向量指令_)(n)));
        }
        case ISK.PHI节点指令: {
            return .输出PHI节点指令((cast(PHI节点指令_)(n)));
        }
        case ISK.着陆场指令: {
            return .输出着陆场指令((cast(着陆场指令_)(n)));
        }
        case ISK.调用指令: {
            return .输出调用指令((cast(调用指令_)(n)));
        }
        case ISK.实参表达式: {
            return .输出实参表达式((cast(实参表达式_)(n)));
        }
        case ISK.冻结指令: {
            return .输出冻结指令((cast(冻结指令_)(n)));
        }
        case ISK.分配指令: {
            return .输出分配指令((cast(分配指令_)(n)));
        }
        case ISK.加载指令: {
            return .输出加载指令((cast(加载指令_)(n)));
        }
        case ISK.储存指令: {
            return .输出储存指令((cast(储存指令_)(n)));
        }
        case ISK.原子修改内存按条件指令: {
            return .输出原子修改内存按条件指令((cast(原子修改内存按条件指令_)(n)));
        }
        case ISK.原子修改内存指令: {
            return .输出原子修改内存指令((cast(原子修改内存指令_)(n)));
        }
        case ISK.栅格指令: {
            return .输出栅格指令((cast(栅格指令_)(n)));
        }
        case ISK.获取元素指针指令: {
            return .输出获取元素指针指令((cast(获取元素指针指令_)(n)));
        }
        case ISK.提取值指令: {
            return .输出提取值指令((cast(提取值指令_)(n)));
        }
        case ISK.插入值指令: {
            return .输出插入值指令((cast(插入值指令_)(n)));
        }
        case ISK.结构常量表达式: {
            return .输出结构常量表达式((cast(结构常量表达式_)(n)));
        }
        case ISK.向量常量表达式: {
            return .输出向量常量表达式((cast(向量常量表达式_)(n)));
        }
        case ISK.数组常量表达式: {
            return .输出数组常量表达式((cast(数组常量表达式_)(n)));
        }
        case ISK.c文本常量: {
            return .输出c文本常量((cast(c文本常量_)(n)));
        }
        case ISK.内联汇编常量表达式: {
            return .输出内联汇编常量表达式((cast(内联汇编常量表达式_)(n)));
        }
        case ISK.块地址表常量表达式: {
            return .输出块地址表常量表达式((cast(块地址表常量表达式_)(n)));
        }
        case ISK.DSO局部等效常量表达式: {
            return .输出DSO局部等效常量表达式((cast(DSO局部等效常量表达式_)(n)));
        }
        case ISK.常量转换类节点: {
            return .输出常量转换类节点((cast(常量转换类节点_)(n)));
        }
        case ISK.提取值常量表达式: {
            return .输出提取值常量表达式((cast(提取值常量表达式_)(n)));
        }
        case ISK.插入值常量表达式: {
            return .输出插入值常量表达式((cast(插入值常量表达式_)(n)));
        }
        case ISK.比较类常量表达式: {
            return .输出比较类常量表达式((cast(比较类常量表达式_)(n)));
        }
        case ISK.取反常量表达式: {
            return .输出取反常量表达式((cast(取反常量表达式_)(n)));
        }
        case ISK.二元常量表达式: {
            return .输出二元常量表达式((cast(二元常量表达式_)(n)));
        }
        case ISK.逻辑类常量表达式: {
            return .输出逻辑类常量表达式((cast(逻辑类常量表达式_)(n)));
        }
        case ISK.获取元素指针常量表达式: {
            return .输出获取元素指针常量表达式((cast(获取元素指针常量表达式_)(n)));
        }
        case ISK.向量洗牌常量表达式: {
            return .输出向量洗牌常量表达式((cast(向量洗牌常量表达式_)(n)));
        }
        case ISK.插入元素常量表达式: {
            return .输出插入元素常量表达式((cast(插入元素常量表达式_)(n)));
        }
        case ISK.提取元素常量表达式: {
            return .输出提取元素常量表达式((cast(提取元素常量表达式_)(n)));
        }
        case ISK.选择常量表达式: {
            return .输出选择常量表达式((cast(选择常量表达式_)(n)));
        }
        case ISK.同步范围设置: {
            return .输出同步范围设置((cast(同步范围设置_)(n)));
        }
        case ISK.捕获或过滤器: {
            return .输出捕获或过滤器((cast(捕获或过滤器_)(n)));
        }
        case ISK.PHI节点元素: {
            return .输出PHI节点元素((cast(PHI节点元素_)(n)));
        }
        case ISK.操作数标签组: {
            return .输出操作数标签组((cast(操作数标签组_)(n)));
        }
        case ISK.操作数标签: {
            return .输出操作数标签((cast(操作数标签_)(n)));
        }
        case ISK.true_:
        case ISK.false_:
        case ISK.null_:
        case ISK.undef:
        case ISK.poison:
        case ISK.zeroinitializer:
        case ISK.none: {
            return writeKeyword(.获取关键字(n.目标种类));
        }
        case ISK.文本字面量: {
            return .输出文本字面量((cast(IR文本字面量_)(n)));
        }
        case ISK.数字字面量: {
            return .输出数字字面量((cast(IR数字字面量_)(n)));
        }
        case ISK.c文本字面量: {
            return .输出IRc文本字面量((cast(IRc文本字面量_)(n)));
        }
        case ISK.标识符: {
            return .输出标识符((cast(IR标识符_)(n)));
        }
        case ISK.全局表达式: {
            return .输出全局表达式((cast(全局表达式_)(n)));
        }
        case ISK.值表达式: {
            return .输出值表达式((cast(值表达式_)(n)));
        }
        case ISK.自定义特性设置: {
            return .输出自定义特性设置((cast(自定义特性设置_)(n)));
        }
        case ISK.对齐设置: {
            return .输出对齐设置((cast(对齐设置_)(n)));
        }
        case ISK.不可引用的设置: {
            return .输出不可引用的设置((cast(不可引用的设置_)(n)));
        }
        case ISK.不可引用的或空设置: {
            return .输出不可引用的或空设置((cast(不可引用的或空设置_)(n)));
        }
        case ISK.对齐堆栈设置: {
            return .输出对齐堆栈设置((cast(对齐堆栈设置_)(n)));
        }
        case ISK.分配大小设置: {
            return .输出分配大小设置((cast(分配大小设置_)(n)));
        }
        case ISK.分配大小设置内容: {
            return .输出分配大小设置内容((cast(分配大小设置内容_)(n)));
        }
        case ISK.地址空间设置: {
            return .输出地址空间设置((cast(地址空间设置_)(n)));
        }
        case ISK.按引用设置: {
            return .输出按引用设置((cast(按引用设置_)(n)));
        }
        case ISK.结构引用设置: {
            return .输出结构引用设置((cast(结构引用设置_)(n)));
        }
        case ISK.预分配设置: {
            return .输出预分配设置((cast(预分配设置_)(n)));
        }
        case ISK.按值设置: {
            return .输出按值设置((cast(按值设置_)(n)));
        }
        case ISK.CC调用约定设置: {
            return .输出CC调用约定设置((cast(CC调用约定设置_)(n)));
        }
        case ISK.MDNodeVector: {
            return .输出MDNodeVector((cast(MDNodeVector_)(n)));
        }
        case ISK.DIExpression: {
            return .输出DIExpression((cast(DIExpression_)(n)));
        }
        case ISK.DIArgList: {
            return .输出DIArgList((cast(DIArgList_)(n)));
        }
        case ISK.专用元数据字段: {
            return .输出专用元数据字段((cast(专用元数据字段_)(n)));
        }
        case ISK.元数据字段: {
            return .输出元数据字段((cast(元数据字段_)(n)));
        }
        case ISK.数据计算字段: {
            return .输出数据计算字段((cast(数据计算字段_)(n)));
        }
        default: break;
    }
    if (n.目标种类 >= ISK.define && n.目标种类 <= ISK.vscale) {
        return writeTokenNode(n, cast(void delegate(dstring))(·fd(&writeKeyword)));
    }
    if (n.目标种类 >= ISK.左大括号 && n.目标种类 <= ISK.等号 || n.目标种类 == ISK.三点号 || n.目标种类 == ISK.x) {
        return writeTokenNode(n, cast(void delegate(dstring))(·fd(&writePunctuation)));
    }
    assert(false, "has not emit node"c);
}
void 输出数据计算字段(数据计算字段_ n) {
    emit(n.键);
    writePunctuation(":"d);
    writeSpace();
    emitList(n, ·to!(节点数组_!(基础节点_))(n.运算数组), ListFormat.BarDelimited);
}
void 输出元数据字段(元数据字段_ n) {
    emit(n.键);
    writePunctuation(":"d);
    writeSpace();
    emit(n.值);
}
void 输出专用元数据字段(专用元数据字段_ n) {
    emit(n.键);
    emitList(n, ·to!(节点数组_!(基础节点_))(n.成员), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
}
void 输出DIArgList(DIArgList_ n) {
    writeKeyword("!DIArgList"d);
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
}
void 输出DIExpression(DIExpression_ n) {
    writeKeyword("!DIExpression"d);
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
}
void 输出MDNodeVector(MDNodeVector_ n) {
    writePunctuation("!"d);
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.Braces | ListFormat.SpaceBetweenBraces);
}
void 输出按值设置(按值设置_ n) {
    writeKeyword(.获取关键字(ISK.byval));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出预分配设置(预分配设置_ n) {
    writeKeyword(.获取关键字(ISK.preallocated));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出结构引用设置(结构引用设置_ n) {
    writeKeyword(.获取关键字(ISK.sret));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出按引用设置(按引用设置_ n) {
    writeKeyword(.获取关键字(ISK.byref));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出地址空间设置(地址空间设置_ n) {
    writeKeyword(.获取关键字(ISK.addrspace));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出倍数范围设置(倍数范围设置_ n) {
    writeKeyword(.获取关键字(ISK.vscale_range));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出倍数范围设置内容(倍数范围设置内容_ n) {
    emit(n.最小);
    if (n.最大 !is ··null!(IR数字字面量_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.最大);
    }
}
void 输出分配大小设置内容(分配大小设置内容_ n) {
    emit(n.基本大小);
    if (n.数量 !is ··null!(IR数字字面量_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.数量);
    }
}
void 输出分配大小设置(分配大小设置_ n) {
    writeKeyword(.获取关键字(ISK.allocsize));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出对齐堆栈设置(对齐堆栈设置_ n) {
    writeKeyword(.获取关键字(ISK.alignstack));
    if (n.等号) {
        writeSpace();
        writePunctuation("="d);
        if (n.值 !is ··null!(节点_)) {
            writeSpace();
            emit(n.值);
        }
    }
    else {
        writePunctuation("("d);
        if (n.值 !is ··null!(节点_)) {
            emit(n.值);
        }
        writePunctuation(")"d);
    }
}
void 输出不可引用的或空设置(不可引用的或空设置_ n) {
    writeKeyword(.获取关键字(ISK.dereferenceable_or_null));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出不可引用的设置(不可引用的设置_ n) {
    writeKeyword(.获取关键字(ISK.dereferenceable));
    writePunctuation("("d);
    if (n.值 !is ··null!(节点_)) {
        emit(n.值);
    }
    writePunctuation(")"d);
}
void 输出对齐设置(对齐设置_ n) {
    writeKeyword(.获取关键字(ISK.align_));
    if (n.等号) {
        writeSpace();
        writePunctuation("="d);
    }
    if (n.有括号) {
        writePunctuation("("d);
    }
    else {
        writeSpace();
    }
    emit(n.值);
    if (n.有括号) {
        writePunctuation(")"d);
    }
}
void 输出自定义特性设置(自定义特性设置_ n) {
    emit(n.键);
    if (n.值 !is ··null!(节点_)) {
        writePunctuation("="d);
        emit(n.值);
    }
}
void 输出值表达式(值表达式_ n) {
    emit(n.类型);
    writeSpace();
    emit(n.值);
}
void 输出全局表达式(全局表达式_ n) {
    if (n.InRangeOp !is ··null!(节点_)) {
        writeKeyword(.获取关键字(ISK.inrange));
        writeSpace();
    }
    emit(n.类型);
    writeSpace();
    emit(n.表达式);
}
void 输出文本字面量(IR文本字面量_ n) {
    if ((n.标志 & 节点标志_.MD_) != 0) {
        writeKeyword("!"d);
    }
    if ((n.标志 & 节点标志_.未解码转义) != 0 && ((cast(IR文本字面量_)(n)).原始文本 !is ··null!(dstring))) {
        writeKeyword("\""d ~ (cast(IR文本字面量_)(n)).原始文本 ~ "\""d);
    }
    else {
        writeKeyword("\""d ~ (cast(IR文本字面量_)(n)).内容 ~ "\""d);
    }
}
void 输出数字字面量(IR数字字面量_ n) {
    if ((n.标志 & 节点标志_.MD_) != 0) {
        writeKeyword("!"d);
    }
    writeKeyword((cast(IR数字字面量_)(n)).内容);
}
void 输出标识符(IR标识符_ n) {
    if ((n.分类 & (标识符分类_.全局标识符_ | 标识符分类_.全局变量标识符_ | 标识符分类_.函数名称_)) != 0) {
        writeKeyword("@"d);
    }
    else if ((n.分类 & (标识符分类_.局部标识符_ | 标识符分类_.类型标识符_)) != 0) {
        writeKeyword("%"d);
    }
    else if ((n.分类 & 标识符分类_.封装标识符_) != 0) {
        writeKeyword("$"d);
    }
    else if ((n.分类 & 标识符分类_.元数据标识符_) != 0) {
        writeKeyword("!"d);
    }
    else if ((n.分类 & 标识符分类_.特性标识符_) != 0) {
        writeKeyword("#"d);
    }
    else if ((n.分类 & 标识符分类_.摘要标识符_) != 0) {
        writeKeyword("^"d);
    }
    if ((n.分类 & 标识符分类_.文本内容标识符_) != 0) {
        writeKeyword("\""d);
    }
    writeKeyword(n.内容);
    if ((n.分类 & 标识符分类_.文本内容标识符_) != 0) {
        writeKeyword("\""d);
    }
    if ((n.分类 & 标识符分类_.标签标识符_) != 0) {
        writeKeyword(":"d);
    }
}
void 输出IRc文本字面量(IRc文本字面量_ n) {
    dstring 内容 = n.原始内容;
    writeKeyword("c"d);
    writeKeyword("\""d ~ 内容 ~ "\""d);
}
void 输出选择常量表达式(选择常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.select));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    if (n.Val2 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val2);
    }
    writePunctuation(")"d);
}
void 输出提取元素常量表达式(提取元素常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.extractelement));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    writePunctuation(")"d);
}
void 输出插入元素常量表达式(插入元素常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.insertelement));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    if (n.Val2 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val2);
    }
    writePunctuation(")"d);
}
void 输出向量洗牌常量表达式(向量洗牌常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.shufflevector));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    if (n.Val2 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val2);
    }
    writePunctuation(")"d);
}
void 输出获取元素指针常量表达式(获取元素指针常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.getelementptr));
    if (n.在界内 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.inbounds));
    }
    writePunctuation("("d);
    if (n.类型 !is ··null!(节点_)) {
        emit(n.类型);
    }
    if ((n.索引表 !is null) && (n.索引表.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引表), ListFormat.逗号间隔列表);
    }
    writePunctuation(")"d);
}
void 输出逻辑类常量表达式(逻辑类常量表达式_ n) {
    writeKeyword(.获取关键字(n.op.目标种类));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    writePunctuation(")"d);
}
void 输出二元常量表达式(二元常量表达式_ n) {
    writeKeyword(.获取关键字(n.op.目标种类));
    if (n.NUW !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.nuw));
    }
    if (n.NSW !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.nsw));
    }
    if (n.Exact !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.exact));
    }
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    writePunctuation(")"d);
}
void 输出取反常量表达式(取反常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.fneg));
    writePunctuation("("d);
    emit(n.Val);
    writePunctuation(")"d);
}
void 输出比较类常量表达式(比较类常量表达式_ n) {
    writeKeyword(.获取关键字(n.kind.目标种类));
    if (n.PredVal !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.PredVal.目标种类));
    }
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    writePunctuation(")"d);
}
void 输出插入值常量表达式(插入值常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.insertvalue));
    writePunctuation("("d);
    if (n.Val0 !is ··null!(节点_)) {
        emit(n.Val0);
    }
    if (n.Val1 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Val1);
    }
    if ((n.Indices !is null) && (n.Indices.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.Indices), ListFormat.逗号间隔列表);
    }
    writePunctuation(")"d);
}
void 输出提取值常量表达式(提取值常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.extractvalue));
    writePunctuation("("d);
    if (n.Val !is ··null!(节点_)) {
        emit(n.Val);
    }
    if ((n.Indices !is null) && (n.Indices.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.Indices), ListFormat.逗号间隔列表);
    }
    writePunctuation(")"d);
}
void 输出常量转换类节点(常量转换类节点_ n) {
    writeKeyword(.获取关键字(n.op.目标种类));
    writePunctuation("("d);
    if (n.srcVal !is ··null!(节点_)) {
        emit(n.srcVal);
    }
    if (n.DestTy !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.DestTy);
    }
    writePunctuation(")"d);
}
void 输出DSO局部等效常量表达式(DSO局部等效常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.dso_local_equivalent));
    if (n.函数_ !is ··null!(节点_)) {
        writeSpace();
        emit(n.函数_);
    }
}
void 输出块地址表常量表达式(块地址表常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.blockaddress));
    writePunctuation("("d);
    if (n.函数_ !is ··null!(节点_)) {
        emit(n.函数_);
    }
    if (n.标签 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.标签);
    }
    writePunctuation(")"d);
}
void 输出内联汇编常量表达式(内联汇编常量表达式_ n) {
    writeKeyword(.获取关键字(ISK.asm_));
    if (n.HasSideEffect !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.sideeffect));
    }
    if (n.AlignStack !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.alignstack));
    }
    if (n.AsmDialect !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.inteldialect));
    }
    if (n.CanThrow !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.unwind));
    }
    if (n.StrVal !is ··null!(IR文本字面量_)) {
        writeSpace();
        emit(n.StrVal);
    }
    if (n.StrVal2 !is ··null!(IR文本字面量_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.StrVal2);
    }
}
void 输出c文本常量(c文本常量_ n) {
    emit(n.内容);
}
void 输出数组常量表达式(数组常量表达式_ n) {
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets | ListFormat.SpaceBetweenBraces);
}
void 输出向量常量表达式(向量常量表达式_ n) {
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.AngleBrackets | ListFormat.SpaceBetweenBraces);
}
void 输出结构常量表达式(结构常量表达式_ n) {
    if (n.是压缩的) {
        writePunctuation("<"d);
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.元素组), ListFormat.逗号间隔列表 | ListFormat.Braces | ListFormat.SpaceBetweenBraces);
    if (n.是压缩的) {
        writePunctuation(">"d);
    }
}
void 输出插入值指令(插入值指令_ n) {
    writeKeyword(.获取关键字(ISK.insertvalue));
    writeSpace();
    emit(n.值0);
    writePunctuation(","d);
    writeSpace();
    emit(n.值1);
    if ((n.索引表 !is null) && (n.索引表.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引表), ListFormat.逗号间隔列表);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出提取值指令(提取值指令_ n) {
    writeKeyword(.获取关键字(ISK.extractvalue));
    writeSpace();
    emit(n.值);
    if ((n.索引表 !is null) && (n.索引表.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引表), ListFormat.逗号间隔列表);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出获取元素指针指令(获取元素指针指令_ n) {
    writeKeyword(.获取关键字(ISK.getelementptr));
    if (n.在界内 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.inbounds));
    }
    writeSpace();
    emit(n.类型);
    writePunctuation(","d);
    writeSpace();
    emit(n.值0);
    if ((n.索引组 !is null) && (n.索引组.原型 !is ··null!(值表达式_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引组), ListFormat.逗号间隔列表);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出栅格指令(栅格指令_ n) {
    writeKeyword(.获取关键字(ISK.fence));
    if (n.同步 !is ··null!(同步范围设置_)) {
        writeSpace();
        emit(n.同步);
    }
    if (n.排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.排序.目标种类));
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出原子修改内存指令(原子修改内存指令_ n) {
    writeKeyword(.获取关键字(ISK.atomicrmw));
    if (n.isVolatile !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.volatile));
    }
    if (n.排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.排序.目标种类));
    }
    writeSpace();
    emit(n.值0);
    writePunctuation(","d);
    writeSpace();
    emit(n.值1);
    if (n.同步 !is ··null!(同步范围设置_)) {
        writeSpace();
        emit(n.同步);
    }
    if (n.Alignment !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Alignment);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出原子修改内存按条件指令(原子修改内存按条件指令_ n) {
    writeKeyword(.获取关键字(ISK.cmpxchg));
    if (n.isWeak !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.weak));
    }
    if (n.isVolatile !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.volatile));
    }
    writeSpace();
    emit(n.值0);
    writePunctuation(","d);
    writeSpace();
    emit(n.值1);
    writePunctuation(","d);
    writeSpace();
    emit(n.值2);
    if (n.同步 !is ··null!(同步范围设置_)) {
        writeSpace();
        emit(n.同步);
    }
    if (n.真排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.真排序.目标种类));
    }
    if (n.假排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.假排序.目标种类));
    }
    if (n.Alignment !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Alignment);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出储存指令(储存指令_ n) {
    writeKeyword(.获取关键字(ISK.store));
    if (n.isAtomic !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.atomic));
    }
    if (n.isVolatile !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.volatile));
    }
    writeSpace();
    emit(n.值0);
    writePunctuation(","d);
    writeSpace();
    emit(n.值1);
    if (n.同步 !is ··null!(同步范围设置_)) {
        writeSpace();
        emit(n.同步);
    }
    if (n.排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.排序.目标种类));
    }
    if (n.Alignment !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Alignment);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出同步范围设置(同步范围设置_ n) {
    writeKeyword(.获取关键字(ISK.syncscope));
    writePunctuation("("d);
    emit(n.值);
    writePunctuation(")"d);
}
void 输出加载指令(加载指令_ n) {
    writeKeyword(.获取关键字(ISK.load));
    if (n.isAtomic !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.atomic));
    }
    if (n.isVolatile !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.volatile));
    }
    writeSpace();
    emit(n.类型);
    writePunctuation(","d);
    writeSpace();
    emit(n.表达式);
    if (n.同步 !is ··null!(同步范围设置_)) {
        writeSpace();
        emit(n.同步);
    }
    if (n.排序 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.排序.目标种类));
    }
    if (n.Alignment !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Alignment);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出分配指令(分配指令_ n) {
    writeKeyword(.获取关键字(ISK.alloca));
    if (n.IsInAlloca !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.inalloca));
    }
    if (n.IsSwiftError !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.swifterror));
    }
    writeSpace();
    emit(n.类型);
    if (n.Size !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Size);
        if (n.Alignment !is ··null!(节点_)) {
            writeSpace();
            emit(n.Alignment);
        }
        if (n.AddrSpace !is ··null!(节点_)) {
            writeSpace();
            emit(n.AddrSpace);
        }
    }
    else if (n.Alignment !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.Alignment);
        if (n.AddrSpace !is ··null!(节点_)) {
            writeSpace();
            emit(n.AddrSpace);
        }
    }
    else if (n.AddrSpace !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.AddrSpace);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出实参表达式(实参表达式_ n) {
    if ((n.参数特性 !is null) && (n.参数特性.原型 !is ··null!(节点_[]))) {
        值表达式_ 表达式 = (cast(值表达式_)(n.表达式));
        emit(表达式.类型);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.参数特性), ListFormat.空白_);
        writeSpace();
        emit(表达式.值);
    }
    else {
        emit(n.表达式);
    }
}
void 输出冻结指令(冻结指令_ n) {
    writeKeyword(.获取关键字(ISK.freeze));
    if (n.表达式 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出调用指令(调用指令_ n) {
    if (n.尾调用修饰符 !is ··null!(节点_)) {
        emit(n.尾调用修饰符);
        writeSpace();
    }
    writeKeyword(.获取关键字(ISK.call));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    if (n.调用约定 !is ··null!(节点_)) {
        writeSpace();
        emit(n.调用约定);
    }
    if ((n.返回类型特性 !is null) && (n.返回类型特性.原型 !is ··null!(节点_[])) && n.返回类型特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.返回类型特性), ListFormat.空白_);
    }
    if (n.地址空间 !is ··null!(地址空间设置_)) {
        writeSpace();
        emit(n.地址空间);
    }
    if (n.返回类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.返回类型);
    }
    if (n.name !is ··null!(节点_)) {
        writeSpace();
        emit(n.name);
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.实参列表), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
    if ((n.函数特性组 !is null) && (n.函数特性组.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性组), ListFormat.空白_);
    }
    if (n.捆绑的操作数 !is ··null!(操作数标签组_)) {
        writeSpace();
        emit(n.捆绑的操作数);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出着陆场指令(着陆场指令_ n) {
    writeKeyword(.获取关键字(ISK.landingpad));
    if (n.类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.类型);
    }
    if (n.清理指令 !is ··null!(节点_)) {
        writeSpace();
        emit(n.清理指令);
    }
    if ((n.捕获或过滤器 !is null) && (n.捕获或过滤器.原型 !is ··null!(捕获或过滤器_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.捕获或过滤器), ListFormat.空白_);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出捕获或过滤器(捕获或过滤器_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if (n.捕获_ !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.捕获_);
    }
}
void 输出PHI节点元素(PHI节点元素_ n) {
    writePunctuation("["d);
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    writePunctuation("]"d);
}
void 输出PHI节点指令(PHI节点指令_ n) {
    writeKeyword(.获取关键字(ISK.phi));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    if (n.类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.类型);
    }
    if ((n.节点组 !is null) && (n.节点组.原型 !is ··null!(PHI节点元素_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.节点组), ListFormat.空白_);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出洗牌向量指令(洗牌向量指令_ n) {
    writeKeyword(.获取关键字(ISK.shufflevector));
    if (n.值0 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值0);
    }
    if (n.值1 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值1);
    }
    if (n.值2 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值2);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出插入元素指令(插入元素指令_ n) {
    writeKeyword(.获取关键字(ISK.insertelement));
    if (n.值0 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值0);
    }
    if (n.值1 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值1);
    }
    if (n.值2 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值2);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出提取元素指令(提取元素指令_ n) {
    writeKeyword(.获取关键字(ISK.extractelement));
    if (n.值0 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值0);
    }
    if (n.值1 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值1);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出可变参数指令(可变参数指令_ n) {
    writeKeyword(.获取关键字(ISK.va_arg));
    if (n.值 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值);
    }
    if (n.类型 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.类型);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出转换类指令(转换类指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if (n.左值 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.左值);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.to));
    if (n.目标类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.目标类型);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出选择指令(选择指令_ n) {
    writeKeyword(.获取关键字(ISK.select));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    if (n.值0 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值0);
    }
    if (n.值1 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值1);
    }
    if (n.值2 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.值2);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出比较运算指令(比较运算指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if (n.副词 !is ··null!(节点_)) {
        writeSpace();
        emit(n.副词);
    }
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出位运算指令(位运算指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出有无符号求余数运算指令(有无符号求余数运算指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出有无符号求商及右移指令(有无符号求商及右移指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if (n.快速标志 !is ··null!(节点_)) {
        writeSpace();
        emit(n.快速标志);
    }
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出小数和差积及左移指令(小数和差积及左移指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出整数和差积及左移指令(整数和差积及左移指令_ n) {
    writeKeyword(.获取关键字(n.指令.目标种类));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    writeSpace();
    emit(n.左值);
    writePunctuation(","d);
    writeSpace();
    emit(n.右值);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出取反指令(取反指令_ n) {
    writeKeyword(.获取关键字(ISK.fneg));
    if ((n.快速标志 !is null) && (n.快速标志.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.快速标志), ListFormat.空白_);
    }
    if (n.运算数 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.运算数);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出调用跳转指令(调用跳转指令_ n) {
    writeKeyword(.获取关键字(ISK.callbr));
    if (n.调用约定 !is ··null!(节点_)) {
        writeSpace();
        emit(n.调用约定);
    }
    if ((n.返回类型特性 !is null) && (n.返回类型特性.原型 !is ··null!(节点_[])) && n.返回类型特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.返回类型特性), ListFormat.空白_);
    }
    if (n.返回类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.返回类型);
    }
    if (n.name !is ··null!(节点_)) {
        writeSpace();
        emit(n.name);
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.实参列表), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
    if ((n.函数特性组 !is null) && (n.函数特性组.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性组), ListFormat.空白_);
    }
    if (n.捆绑的操作数 !is ··null!(操作数标签组_)) {
        writeSpace();
        emit(n.捆绑的操作数);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.to));
    if (n.默认标签 !is ··null!(节点_)) {
        writeSpace();
        emit(n.默认标签);
    }
    if ((n.转到块 !is null) && (n.转到块.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.转到块), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出清理场指令(清理场指令_ n) {
    writeKeyword(.获取关键字(ISK.cleanuppad));
    writeSpace();
    writeKeyword(.获取关键字(ISK.within));
    if (n.表达式 !is ··null!(节点_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.异常参数 !is null) && (n.异常参数.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.异常参数), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出捕获场指令(捕获场指令_ n) {
    writeKeyword(.获取关键字(ISK.catchpad));
    writeSpace();
    writeKeyword(.获取关键字(ISK.within));
    if (n.表达式 !is ··null!(节点_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.异常参数 !is null) && (n.异常参数.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.异常参数), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出捕获分支指令(捕获分支指令_ n) {
    writeKeyword(.获取关键字(ISK.catchswitch));
    writeSpace();
    writeKeyword(.获取关键字(ISK.within));
    if (n.表达式 !is ··null!(节点_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.地址表 !is null) && (n.地址表.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.地址表), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.unwind));
    if (n.展开标签 is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.to));
        writeSpace();
        writeKeyword(.获取关键字(ISK.caller));
    }
    else {
        writeSpace();
        emit(n.展开标签);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出捕获返回指令(捕获返回指令_ n) {
    writeKeyword(.获取关键字(ISK.catchret));
    writeSpace();
    writeKeyword(.获取关键字(ISK.from));
    if (n.起始块 !is ··null!(节点_)) {
        writeSpace();
        emit(n.起始块);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.to));
    if (n.目标块 !is ··null!(节点_)) {
        writeSpace();
        emit(n.目标块);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出清理返回指令(清理返回指令_ n) {
    writeKeyword(.获取关键字(ISK.cleanupret));
    writeSpace();
    writeKeyword(.获取关键字(ISK.from));
    if (n.起始块 !is ··null!(节点_)) {
        writeSpace();
        emit(n.起始块);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.unwind));
    if (n.目标块 is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(ISK.to));
        writeSpace();
        writeKeyword(.获取关键字(ISK.caller));
    }
    else {
        writeSpace();
        emit(n.目标块);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出重启指令(重启指令_ n) {
    writeKeyword(.获取关键字(ISK.resume));
    if (n.表达式 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出操作数标签(操作数标签_ n) {
    emit(n.name);
    if ((n.标签组 !is null) && (n.标签组.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.标签组), ListFormat.空白_ | ListFormat.SquareBrackets);
    }
}
void 输出操作数标签组(操作数标签组_ n) {
    emitList(n, ·to!(节点数组_!(基础节点_))(n.标签组), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
}
void 输出唤出指令(唤出指令_ n) {
    writeKeyword(.获取关键字(ISK.invoke));
    if (n.调用约定 !is ··null!(节点_)) {
        writeSpace();
        emit(n.调用约定);
    }
    if ((n.返回类型特性 !is null) && (n.返回类型特性.原型 !is ··null!(节点_[])) && n.返回类型特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.返回类型特性), ListFormat.空白_);
    }
    if (n.地址空间 !is ··null!(地址空间设置_)) {
        writeSpace();
        emit(n.地址空间);
    }
    if (n.返回类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.返回类型);
    }
    if (n.name !is ··null!(节点_)) {
        writeSpace();
        emit(n.name);
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.实参列表), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
    if ((n.函数特性组 !is null) && (n.函数特性组.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性组), ListFormat.空白_);
    }
    if (n.捆绑的操作数 !is ··null!(操作数标签组_)) {
        writeSpace();
        emit(n.捆绑的操作数);
    }
    writeSpace();
    writeKeyword(.获取关键字(ISK.to));
    writeSpace();
    emit(n.转到块);
    writeSpace();
    writeKeyword(.获取关键字(ISK.unwind));
    writeSpace();
    emit(n.异常块);
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出直接跳转指令(直接跳转指令_ n) {
    writeKeyword(.获取关键字(ISK.indirectbr));
    if (n.值 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.值);
    }
    if ((n.跳转表 !is null) && (n.跳转表.原型 !is ··null!(值表达式_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.跳转表), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出跳转表元素(跳转表元素_ n) {
    emit(n.条件);
    writePunctuation(","d);
    writeSpace();
    emit(n.标签);
}
void 输出假如指令(假如指令_ n) {
    writeKeyword(.获取关键字(ISK.switch_));
    if (n.条件 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.条件);
    }
    if (n.标签 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.标签);
    }
    if ((n.跳转表 !is null) && (n.跳转表.原型 !is ··null!(跳转表元素_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.跳转表), ListFormat.逗号间隔列表 | ListFormat.SquareBrackets);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出跳转指令(跳转指令_ n) {
    writeKeyword(.获取关键字(ISK.br));
    if (n.条件 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.条件);
    }
    if (n.为真 !is ··null!(值表达式_)) {
        if (n.条件 !is ··null!(值表达式_)) {
            writePunctuation(","d);
        }
        writeSpace();
        emit(n.为真);
    }
    if (n.为假 !is ··null!(值表达式_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.为假);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出返回指令(返回指令_ n) {
    writeKeyword(.获取关键字(ISK.ret));
    if (n.表达式 !is ··null!(值表达式_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出不及指令(不及指令_ n) {
    writeKeyword(.获取关键字(ISK.unreachable));
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    writeLine();
}
void 输出局部变量声明(局部变量声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    emit(n.初始化);
}
void 输出形参声明(形参声明_ n) {
    emit(n.类型);
    if ((n.形参特性 !is null) && (n.形参特性.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.形参特性), ListFormat.空白_);
    }
    if (n.name !is ··null!(IR标识符_)) {
        writeSpace();
        emit(n.name);
    }
}
void 输出类型引用(类型引用_ n) {
    emit(n.类型名);
}
void 输出向量类型(向量类型_ n) {
    writePunctuation("<"d);
    if (n.Vector !is ··null!(节点_)) {
        writeKeyword(.获取关键字(ISK.vscale));
        writeSpace();
        writeKeyword(.获取关键字(ISK.x));
        writeSpace();
    }
    emit(n.数量);
    writeSpace();
    writeKeyword(.获取关键字(ISK.x));
    writeSpace();
    emit(n.类型);
    writePunctuation(">"d);
}
void 输出数组类型(数组类型_ n) {
    writePunctuation("["d);
    emit(n.数量);
    writeSpace();
    writeKeyword(.获取关键字(ISK.x));
    writeSpace();
    emit(n.类型);
    writePunctuation("]"d);
}
void 输出结构类型(结构类型_ n) {
    if (n.是压缩的) {
        writePunctuation("<"d);
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.类型组), ListFormat.逗号间隔列表 | ListFormat.Braces | ListFormat.SpaceBetweenBraces);
    if (n.是压缩的) {
        writePunctuation(">"d);
    }
}
void 输出不透明指针类型(不透明指针类型_ n) {
    if (n.地址空间 !is ··null!(节点_)) {
        writeSpace();
        emit(n.地址空间);
    }
    writePunctuation("*"d);
}
void 输出函数类型(函数类型_ n) {
    emit(n.返回类型);
    writeSpace();
    emitList(n, ·to!(节点数组_!(基础节点_))(n.形参组), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
}
void 输出指针类型(指针类型_ n) {
    emit(n.类型);
    if (n.地址空间 !is ··null!(地址空间设置_)) {
        writeSpace();
        emit(n.地址空间);
    }
    writePunctuation("*"d);
}
void 输出整数类型(整数类型_ n) {
    writeKeyword("i"d);
    emit(n.大小);
}
void 输出全局摘要声明(全局摘要声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    emit(n.初始化);
    writeLine();
}
void 输出用户历史数据_基本块(用户历史数据_基本块_ n) {
    writeKeyword(.获取关键字(ISK.uselistorder_bb));
    writeSpace();
    emit(n.函数_);
    writePunctuation(","d);
    writeSpace();
    emit(n.标签);
    writePunctuation(","d);
    writeSpace();
    if ((n.索引表 !is null) && (n.索引表.原型 !is ··null!(节点_[])) && n.索引表.length > 0) {
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引表), ListFormat.逗号间隔列表 | ListFormat.Braces);
    }
    writeLine();
}
void 输出用户历史数据(用户历史数据_ n) {
    writeKeyword(.获取关键字(ISK.uselistorder));
    writeSpace();
    emit(n.值);
    writePunctuation(","d);
    writeSpace();
    if ((n.索引表 !is null) && (n.索引表.原型 !is ··null!(节点_[])) && n.索引表.length > 0) {
        emitList(n, ·to!(节点数组_!(基础节点_))(n.索引表), ListFormat.逗号间隔列表 | ListFormat.Braces);
    }
    writeLine();
}
void 输出特性声明(特性声明_ n) {
    writeKeyword(.获取关键字(ISK.attributes));
    writeSpace();
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    if ((n.成员 !is null) && (n.成员.原型 !is ··null!(节点_[])) && n.成员.length > 0) {
        emitList(n, ·to!(节点数组_!(基础节点_))(n.成员), ListFormat.空白_ | ListFormat.Braces | ListFormat.SpaceBetweenBraces);
    }
    writeLine();
}
void 输出元数据声明(元数据声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    writePunctuation("!"d);
    if ((n.成员组 !is null) && (n.成员组.原型 !is ··null!(节点_[])) && n.成员组.length > 0) {
        emitList(n, ·to!(节点数组_!(基础节点_))(n.成员组), ListFormat.逗号间隔列表 | ListFormat.Braces | ListFormat.SpaceBetweenBraces);
    }
    writeLine();
}
void 输出独立元数据(独立元数据_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    if (n.新鲜的 !is ··null!(节点_)) {
        writeSpace();
        emit(n.新鲜的);
    }
    writeSpace();
    emit(n.元数据);
    writeLine();
}
void 输出类型声明(类型声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    writeKeyword(.获取关键字(ISK.type));
    writeSpace();
    emit(n.类型);
    writeLine();
}
void 输出封装声明(封装声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    writeKeyword(.获取关键字(ISK.comdat));
    writeSpace();
    emit(n.值);
    writeLine();
}
void 输出目标语句(目标语句_ n) {
    writeKeyword(.获取关键字(ISK.target));
    writeSpace();
    emit(n.值);
    writeLine();
}
void 输出源码文件名语句(源码文件名语句_ n) {
    writeKeyword(.获取关键字(ISK.source_filename));
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    emit(n.值);
    writeLine();
}
void 输出参数列表(节点_ n, 节点数组_!(节点_) args) {
    emitList(n, ·to!(节点数组_!(基础节点_))(args), ListFormat.逗号间隔列表 | ListFormat.Parenthesis);
}
void 输出函数声明(函数声明_ n) {
    writeKeyword(.获取关键字(ISK.declare));
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.空白_);
    }
    if (n.连接特性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.连接特性);
    }
    if (n.运行时抢占 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.运行时抢占.目标种类));
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.可见性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.可见性);
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.调用约定 !is ··null!(节点_)) {
        writeSpace();
        emit(n.调用约定);
    }
    if ((n.返回类型特性 !is null) && (n.返回类型特性.原型 !is ··null!(节点_[])) && n.返回类型特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.返回类型特性), ListFormat.空白_);
    }
    writeSpace();
    emit(n.返回类型);
    writeSpace();
    emit(n.name);
    .输出参数列表(n, n.参数列表);
    if (n.未命名的地址 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.未命名的地址.目标种类));
    }
    if (n.地址空间 !is ··null!(节点_)) {
        writeSpace();
        emit(n.地址空间);
    }
    if ((n.函数特性 !is null) && (n.函数特性.原型 !is ··null!(节点_[])) && n.函数特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性), ListFormat.空白_);
    }
    if (n.段设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.段设置);
    }
    if (n.隔板设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.隔板设置);
    }
    if (n.函数封装 !is ··null!(节点_)) {
        writeSpace();
        emit(n.函数封装);
    }
    if (n.对齐设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.对齐设置);
    }
    if (n.GC设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.GC设置);
    }
    if (n.前缀设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.前缀设置);
    }
    if (n.序言设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.序言设置);
    }
    if (n.个性设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.个性设置);
    }
    writeLine();
}
void 输出函数定义(函数定义_ n) {
    writeKeyword(.获取关键字(ISK.define));
    if (n.连接特性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.连接特性);
    }
    if (n.运行时抢占 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.运行时抢占.目标种类));
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.可见性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.可见性);
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.调用约定 !is ··null!(节点_)) {
        writeSpace();
        emit(n.调用约定);
    }
    if ((n.返回类型特性 !is null) && (n.返回类型特性.原型 !is ··null!(节点_[])) && n.返回类型特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.返回类型特性), ListFormat.空白_);
    }
    writeSpace();
    emit(n.返回类型);
    writeSpace();
    emit(n.name);
    .输出参数列表(n, n.参数列表);
    if (n.未命名的地址 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.未命名的地址.目标种类));
    }
    if (n.地址空间 !is ··null!(节点_)) {
        writeSpace();
        emit(n.地址空间);
    }
    if ((n.函数特性 !is null) && (n.函数特性.原型 !is ··null!(节点_[])) && n.函数特性.length > 0) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性), ListFormat.空白_);
    }
    if (n.段设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.段设置);
    }
    if (n.隔板设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.隔板设置);
    }
    if (n.函数封装 !is ··null!(节点_)) {
        writeSpace();
        emit(n.函数封装);
    }
    if (n.对齐设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.对齐设置);
    }
    if (n.GC设置 !is ··null!(节点_)) {
        writeSpace();
        emit(n.GC设置);
    }
    if (n.前缀设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.前缀设置);
    }
    if (n.序言设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.序言设置);
    }
    if (n.个性设置 !is ··null!(全局表达式_)) {
        writeSpace();
        emit(n.个性设置);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.空白_);
    }
    writeSpace();
    emit(n.函数体);
}
void 输出函数体(函数体_ n) {
    节点数组_!(节点_) 语句组 = n.基本块组;
    if (n.用户数据 !is ··null!(用户历史数据_)) {
        语句组 = new 节点数组_!(节点_)(.追加!(节点_)(n.基本块组, n.用户数据));
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(语句组), ListFormat.MultiLine | ListFormat.Braces);
    writeLine();
}
void 输出块声明(块声明_ n) {
    if (n.name !is ··null!(IR标识符_)) {
        emit(n.name);
        writeLine();
    }
    emitList(n, ·to!(节点数组_!(基础节点_))(n.语句组), ListFormat.Indented | ListFormat.MultiLine);
}
void 输出模块级汇编(模块级汇编_ n) {
    writeKeyword(.获取关键字(ISK.module_));
    writeSpace();
    writeKeyword(.获取关键字(ISK.asm_));
    writeSpace();
    emit(n.汇编指令);
}
void 输出本地线程设置(本地线程设置_ n) {
    writeKeyword(.获取关键字(ISK.thread_local));
    if (n.值 !is ··null!(节点_)) {
        writePunctuation("("d);
        emit(n.值);
        writePunctuation(")"d);
    }
}
void 输出别名声明(别名声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    if (n.连接特性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.连接特性);
    }
    if (n.运行时抢占 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.运行时抢占.目标种类));
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.可见性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.可见性);
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.本地线程设置 !is ··null!(本地线程设置_)) {
        writeSpace();
        emit(n.本地线程设置);
    }
    if (n.未命名的地址 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.未命名的地址.目标种类));
    }
    writeSpace();
    writeKeyword(.获取关键字(n.别名令牌.目标种类));
    if (n.类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.类型);
    }
    writePunctuation(","d);
    if (n.表达式 !is ··null!(节点_)) {
        writeSpace();
        emit(n.表达式);
    }
    if ((n.隔板组 !is null) && (n.隔板组.原型 !is ··null!(节点_[]))) {
        emitList(n, ·to!(节点数组_!(基础节点_))(n.隔板组), ListFormat.逗号间隔列表);
    }
}
void 输出全局变量声明(全局变量声明_ n) {
    emit(n.name);
    writeSpace();
    writePunctuation("="d);
    if (n.连接特性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.连接特性);
    }
    if (n.运行时抢占 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.运行时抢占.目标种类));
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.可见性 !is ··null!(节点_)) {
        writeSpace();
        emit(n.可见性);
    }
    if (n.DLL储存类 !is ··null!(节点_)) {
        writeSpace();
        emit(n.DLL储存类);
    }
    if (n.本地线程设置 !is ··null!(本地线程设置_)) {
        writeSpace();
        emit(n.本地线程设置);
    }
    if (n.未命名的地址 !is ··null!(节点_)) {
        writeSpace();
        writeKeyword(.获取关键字(n.未命名的地址.目标种类));
    }
    if (n.地址空间 !is ··null!(节点_)) {
        writeSpace();
        emit(n.地址空间);
    }
    if (n.外部初始化 !is ··null!(节点_)) {
        writeSpace();
        emit(n.外部初始化);
    }
    if (n.全局或常量 !is ··null!(节点_)) {
        writeSpace();
        emit(n.全局或常量);
    }
    if (n.类型 !is ··null!(节点_)) {
        writeSpace();
        emit(n.类型);
    }
    if (n.初始化 !is ··null!(节点_)) {
        writeSpace();
        emit(n.初始化);
    }
    if (n.段设置 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.段设置);
    }
    if (n.隔板设置 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.隔板设置);
    }
    if (n.对齐设置 !is ··null!(节点_)) {
        writePunctuation(","d);
        writeSpace();
        emit(n.对齐设置);
    }
    if ((n.尾部数据 !is null) && (n.尾部数据.原型 !is ··null!(节点_[]))) {
        writePunctuation(","d);
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.尾部数据), ListFormat.逗号间隔列表);
    }
    if ((n.函数特性 !is null) && (n.函数特性.原型 !is ··null!(节点_[]))) {
        writeSpace();
        emitList(n, ·to!(节点数组_!(基础节点_))(n.函数特性), ListFormat.空白_);
    }
}
void 输出空语句(空语句_ _) {
    writeLine(2);
}
void 输出平台设置(平台设置_ n) {
    writeKeyword(.获取关键字(ISK.triple));
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    emit(n.值);
}
void 输出数据布局设置(数据布局设置_ n) {
    writeKeyword(.获取关键字(ISK.datalayout));
    writeSpace();
    writePunctuation("="d);
    writeSpace();
    emit(n.值);
}
void 输出封装设置(封装设置_ n) {
    writeKeyword(.获取关键字(ISK.comdat));
    if (n.值 !is ··null!(节点_)) {
        writePunctuation("("d);
        emit(n.值);
        writePunctuation(")"d);
    }
}
void 输出CC调用约定设置(CC调用约定设置_ n) {
    writeKeyword(.获取关键字(ISK.cc));
    emit(n.值);
}
